import {defineStore} from 'pinia';
import {computed, ref} from 'vue';
import { useUserStore } from './user'
import { insertCartAPI } from '@/apis/cart'
import { findNewCartListAPI } from '@/apis/cart';
import { debugCartAPI } from '@/apis/cart';
import { delCartAPI } from '@/apis/cart';
import { ElMessage } from 'element-plus'
import http from '@/utils/http'


export const useCartStore=defineStore('cart', () => {
  const userStore = useUserStore()
  const isLogin = computed(() => userStore.userInfo?.token)
const cartList = ref([]);
const addCart = async (goods) => {
  const { skuId, count } = goods
  if (isLogin.value) {
    // 登录之后的加入购车逻辑
      const userId = userStore.userInfo?.id
if (!userId) {
        console.error('添加购物车失败：未找到用户ID')
        ElMessage.error('添加购物车失败：未找到用户ID，请重新登录')
  return // 阻止后续执行
}
console.log('userId:', userId)

      try {
        await insertCartAPI({ skuId, count, userId })
        ElMessage.success('添加购物车成功')
        const res = await findNewCartListAPI(userId)
        cartList.value = res.result || []
      } catch (error) {
        console.error('添加购物车失败', error)
        ElMessage.error('添加购物车失败：' + (error.response?.data || error.message))
      }
  } else {
    // // 登录之前的加入购车逻辑
      const item = cartList.value.find((item) => goods.skuId === item.skuId)
      if (item) {
        // 找到了
        item.count++
      } else {
        // 没找到
        cartList.value.push(goods)
      }
      ElMessage.success('添加购物车成功')
    }
};

// 获取最新购物车列表
const updateNewList = async () => {
    // 先检查是否登录
    if (!isLogin.value) {
      console.warn('用户未登录，无法获取购物车列表')
      return
    }
    
    const userId = userStore.userInfo?.id
    if (!userId) {
      console.error('获取购物车列表失败：缺少userId')
      return
    }
    
    try {
      const res = await findNewCartListAPI(userId)
      console.log('购物车数据响应:', res)
      
      // 处理响应数据格式
      if (res.data && res.data.code === 1) {
        // 标准Result格式
        cartList.value = res.data.data || []
        console.log('购物车数据已更新 (Result格式):', cartList.value)
      } else if (res.result) {
        // 直接返回result字段
        cartList.value = res.result || []
        console.log('购物车数据已更新 (result格式):', cartList.value)
      } else if (Array.isArray(res.data)) {
        // 直接返回数据数组
        cartList.value = res.data
        console.log('购物车数据已更新 (Array格式):', cartList.value)
      } else if (res.data) {
        // 其他可能的数据格式
        cartList.value = res.data
        console.log('购物车数据已更新 (其他格式):', cartList.value)
      } else {
        console.error('返回的数据格式不符合预期', res)
        cartList.value = []
      }
      
      // 如果购物车为空，尝试调试接口
      if (cartList.value.length === 0) {
        debugCartData(userId);
      }
    } catch (error) {
      console.error('获取购物车列表失败', error)
      // 保留原有购物车数据，不要清空
      
      // 尝试调试接口
      debugCartData(userId);
    }
  }
  
  // 调试购物车数据
  const debugCartData = async (userId) => {
    try {
      console.log('开始调试购物车数据...');
      const res = await debugCartAPI(userId);
      console.log('调试购物车数据响应:', res);
      
      if (res.data && res.data.data) {
        const debugData = res.data.data;
        console.log('购物车原始数据:', debugData.cartItems);
        console.log('用户数据:', debugData.users);
        console.log('所有购物车数据:', debugData.allCartItems);
        
        // 如果有directCartItems，直接使用
        if (debugData.directCartItems && debugData.directCartItems.length > 0) {
          console.log('使用后端直接构建的购物车项:', debugData.directCartItems);
          cartList.value = debugData.directCartItems;
          console.log('设置购物车数据成功:', cartList.value);
          return;
        }
        
        // 如果有原始数据但映射失败，尝试手动构建购物车项
        if (debugData.allCartItems && debugData.allCartItems.length > 0) {
          const manualCartItems = debugData.allCartItems.map(item => {
            return {
              id: item.id,
              skuId: item.sku_id,
              userId: item.user_id,
              count: item.count,
              selected: item.checked === 1,
              name: item.name,
              price: item.price,
              picture: item.image,
              createTime: item.create_time,
              updateTime: item.update_time
            };
          });
          
          console.log('手动构建的购物车项:', manualCartItems);
          // 如果有当前用户的购物车，则显示
          const userItems = manualCartItems.filter(item => String(item.userId) === String(userId));
          if (userItems.length > 0) {
            cartList.value = userItems;
            console.log('手动设置购物车数据:', cartList.value);
          }
        } else if (debugData.cartItems && debugData.cartItems.length > 0) {
          // 只有原始购物车数据，没有商品关联信息
          console.log('尝试从原始购物车数据构建购物车项');
          const basicItems = debugData.cartItems.map(item => {
            return {
              id: item.id,
              skuId: item.sku_id,
              userId: item.user_id,
              count: item.count,
              selected: item.checked === 1,
              name: '商品 ' + item.sku_id,
              price: 99,  // 默认价格
              picture: 'https://img.picui.cn/free/2025/03/20/67dbcea0b6f32.png',
              createTime: item.create_time,
              updateTime: item.update_time
            };
          });
          
          console.log('从原始数据构建的购物车项:', basicItems);
          if (basicItems.length > 0) {
            cartList.value = basicItems;
            console.log('设置基础购物车数据:', cartList.value);
          }
        }
      }
    } catch (error) {
      console.error('调试购物车数据失败', error);
    }
  };

//删除购物车
const delCart = async (skuId) => {
  if (isLogin.value) {
    // 调用接口实现接口购物车中的删除功能
      const userId = userStore.userInfo?.id
      if (!userId) {
        console.error('删除购物车失败：未找到用户ID')
        return
      }
      
      try {
        await delCartAPI([skuId], userId)
        const res = await findNewCartListAPI(userId)
        
        // 处理响应数据格式
        if (res.data && res.data.code === 1) {
          cartList.value = res.data.data || []
        } else if (res.result) {
          cartList.value = res.result || []
        } else if (Array.isArray(res.data)) {
          cartList.value = res.data
        } else if (res.data) {
          cartList.value = res.data
        } else {
          cartList.value = []
        }
        
        ElMessage.success('删除成功')
      } catch (error) {
        console.error('删除购物车失败', error)
        ElMessage.error('删除失败：' + (error.response?.data || error.message))
      }
  } else {
    // 思路：
    // 1. 找到要删除项的下标值 - splice
    // 2. 使用数组的过滤方法 - filter
    const idx = cartList.value.findIndex((item) => skuId === item.skuId)
    cartList.value.splice(idx, 1)
  }
}

//清除购物车
const clearCart = () => {
  cartList.value = []
}

//单选
const singleCheck = async (skuId, selected) => {
  // 本地状态更新
  const item = cartList.value.find((item) => item.skuId === skuId)
  if (item) {
    item.selected = selected
  }
  
  // 如果用户已登录，同步更新后端状态
  if (isLogin.value) {
    const userId = userStore.userInfo?.id
    if (!userId) {
      console.error('更新选中状态失败：未找到用户ID')
      return
    }
    
    try {
      // 调用后端API更新选中状态
      await http({
        url: '/member/cart/check',
        method: 'POST',
        data: {
          skuId,
          selected
        },
        params: {
          userId
        }
      })
      
      console.log('更新商品选中状态成功')
    } catch (error) {
      console.error('更新商品选中状态失败', error)
    }
  }
}

//计算属性
const allCount =computed (() => {
  return cartList.value.reduce((total, item) => {
    return total + item.count;
  }, 0);
})

const allPrice =computed (() => {
  return cartList.value.reduce((total, item) => {
      return total + (item.price || 0) * item.count;
  }, 0);
})

//是否全选
const allCheck = async (selected) => {
  // 本地状态更新
  cartList.value.forEach(item => item.selected = selected)
  
  // 如果用户已登录，同步更新后端状态
  if (isLogin.value) {
    const userId = userStore.userInfo?.id
    if (!userId) {
      console.error('更新全选状态失败：未找到用户ID')
      return
    }
    
    try {
      // 调用后端API更新全选状态
      await http({
        url: '/member/cart/checkAll',
        method: 'POST',
        data: {
          selected
        },
        params: {
          userId
        }
      })
      
      console.log('更新全选状态成功')
    } catch (error) {
      console.error('更新全选状态失败', error)
    }
  }
}

// 是否全选计算属性
const isAll = computed(() => {
  return cartList.value.length > 0 && cartList.value.every(item => item.selected)
})

// 已选择的商品数量
const selectedCount = computed(() => {
  return cartList.value.filter(item => item.selected).reduce((total, item) => total + item.count, 0)
})

// 已选择的商品总价
const selectedPrice = computed(() => {
  return cartList.value.filter(item => item.selected).reduce((total, item) => {
    return total + (item.price || 0) * item.count
  }, 0)
})

return {
  cartList,
  addCart,
  delCart,
  allCount,
  allPrice,
  singleCheck,
  allCheck,
  isAll,
  selectedCount,
  selectedPrice,
  clearCart,
  updateNewList,
    debugCartData
};
},{
  persist: {
    enabled: true,
    strategies: [
      {
        key: 'cart',
        storage: localStorage,
      },
    ],
  },
  name: 'cart',
});
